// 在线咨询相关API服务
const request = require('../utils/request');

// 获取或创建会话
const getOrCreateConversation = (staffId) => {
  console.log('调用getOrCreateConversation服务，staffId:', staffId);
  
  if (!staffId) {
    console.error('staffId参数为空');
    return Promise.reject(new Error('医生ID不能为空'));
  }
  
  // 确保staffId是字符串类型
  const staffIdStr = String(staffId);
  console.log('转换后的staffId类型:', typeof staffIdStr, '值:', staffIdStr);
  
  return createConversation(staffIdStr)
    .then(res => {
      console.log('创建会话API响应:', res);
      if (typeof res === 'object' && res !== null) {
        return res;
      } else if (typeof res === 'string' || typeof res === 'number') {
        // 如果返回的只是会话ID (字符串或数字)
        return {
          id: res
        };
      } else {
        console.error('创建会话返回格式异常:', res);
        throw new Error('创建会话返回数据格式错误');
      }
    })
    .catch(err => {
      console.error('创建会话API错误:', err);
      // 确保返回一个Promise.reject，以便调用者可以捕获错误
      return Promise.reject(err);
    });
};

/**
 * 创建会话
 */
const createConversation = (staffId) => {
  console.log('调用createConversation服务，staffId:', staffId);
  
  if (!staffId) {
    console.error('staffId参数为空');
    return Promise.reject(new Error('医生ID不能为空'));
  }
  
  return request.post('/consult/conversation', { staffId: String(staffId) })
    .then(res => {
      console.log('创建会话成功:', res);
      return res;
    })
    .catch(err => {
      console.error('创建会话失败:', err);
      return Promise.reject(err);
    });
};

/**
 * 获取用户会话列表
 */
const getUserConversations = () => {
  console.log('调用getUserConversations服务');
  return request.get('/consult/conversation/user')
    .then(res => {
      console.log('获取用户会话列表成功, 原始响应:', res);
      
      // 检查响应格式，确保返回正确的数据结构
      if (res && typeof res === 'object') {
        if (Array.isArray(res)) {
          // 直接返回数组
          console.log('会话列表是数组格式, 长度:', res.length);
          return res;
        } else if (res.data && Array.isArray(res.data)) {
          // 如果响应是 {data: [...]} 格式
          console.log('会话列表在data字段中, 长度:', res.data.length);
          return res.data;
        } else if (res.code === 0 && res.data && Array.isArray(res.data)) {
          // 如果响应是 {code: 0, data: [...]} 格式
          console.log('标准响应格式, 会话列表长度:', res.data.length);
          return res.data;
        } else {
          console.warn('响应格式异常，尝试返回原始响应:', res);
          return res;
        }
      }
      
      console.log('获取用户会话列表成功, 返回数据:', res);
      return res;
    })
    .catch(err => {
      console.error('获取用户会话列表失败, 详细错误:', err);
      return Promise.reject(err);
    });
};

/**
 * 获取医护人员会话列表
 */
const getStaffConversations = () => {
  console.log('调用getStaffConversations服务');
  return request.get('/consult/conversation/staff')
    .then(res => {
      console.log('获取医护人员会话列表成功:', res);
      return res;
    })
    .catch(err => {
      console.error('获取医护人员会话列表失败:', err);
      return Promise.reject(err);
    });
};

/**
 * 获取会话消息历史
 */
const getMessages = (conversationId, page = 1, size = 20) => {
  console.log('调用getMessages服务，conversationId:', conversationId, 'page:', page, 'size:', size);
  
  if (!conversationId) {
    console.error('会话ID参数为空');
    return Promise.reject(new Error('会话ID不能为空'));
  }
  
  return request.get(`/consult/message/${conversationId}`, { page, size })
    .then(res => {
      console.log('获取会话消息成功:', res);
      return res;
    })
    .catch(err => {
      console.error('获取会话消息失败:', err);
      return Promise.reject(err);
    });
};

/**
 * 获取消息列表 (别名，保持兼容性)
 */
const getMessageList = (params) => {
  console.log('调用getMessageList服务，params:', params);
  
  if (!params || !params.conversationId) {
    console.error('会话ID参数为空');
    return Promise.reject(new Error('会话ID不能为空'));
  }
  
  return getMessages(params.conversationId, params.page, params.pageSize)
    .then(res => {
      console.log('获取消息列表成功:', res);
      return res;
    })
    .catch(err => {
      console.error('获取消息列表失败:', err);
      return Promise.reject(err);
    });
};

/**
 * 发送消息
 */
const sendMessage = (conversationId, messageData) => {
  console.log('调用sendMessage服务，conversationId:', conversationId, 'messageData:', messageData);
  
  if (!conversationId) {
    console.error('会话ID参数为空');
    return Promise.reject(new Error('会话ID不能为空'));
  }
  
  return request.post(`/consult/message/${conversationId}`, messageData)
    .then(res => {
      console.log('通过HTTP API发送消息成功:', res);
      return res;
    })
    .catch(err => {
      console.error('通过HTTP API发送消息失败:', err);
      return Promise.reject(err);
    });
};

/**
 * 标记消息为已读
 */
const readMessages = (conversationId) => {
  console.log('调用readMessages服务，conversationId:', conversationId);
  
  if (!conversationId) {
    console.error('会话ID参数为空');
    return Promise.reject(new Error('会话ID不能为空'));
  }
  
  return request.post(`/consult/message/read/${conversationId}`)
    .then(res => {
      console.log('标记消息已读成功:', res);
      return res;
    })
    .catch(err => {
      console.error('标记消息已读失败:', err);
      return Promise.reject(err);
    });
};

/**
 * 结束会话
 */
const endConversation = (conversationId) => {
  console.log('调用endConversation服务，conversationId:', conversationId);
  
  if (!conversationId) {
    console.error('会话ID参数为空');
    return Promise.reject(new Error('会话ID不能为空'));
  }
  
  return request.post(`/consult/conversation/end/${conversationId}`)
    .then(res => {
      console.log('结束会话成功:', res);
      return res;
    })
    .catch(err => {
      console.error('结束会话失败:', err);
      return Promise.reject(err);
    });
};

/**
 * 获取WebSocket连接URL
 * @returns {string} WebSocket URL
 */
function getWsUrl() {
  console.log('获取WebSocket URL');
  try {
    const app = getApp();
    let wsBaseUrl = app.globalData.wsBaseUrl;
    
    // 检查wsBaseUrl是否存在
    if (!wsBaseUrl) {
      console.warn('wsBaseUrl未配置，使用默认值');
      wsBaseUrl = 'ws://localhost:8080';
    }
    
    // 获取当前运行环境
    try {
      const accountInfo = wx.getAccountInfoSync();
      const envVersion = accountInfo.miniProgram.envVersion;
      console.log('当前小程序环境:', envVersion);
      
      // 根据环境调整URL
      if (envVersion === 'develop') {
        // 开发环境
        // 在开发环境中，将localhost替换为127.0.0.1，避免DNS解析问题
        if (wsBaseUrl.includes('localhost')) {
          wsBaseUrl = wsBaseUrl.replace('localhost', '127.0.0.1');
          console.log('开发环境中，将localhost替换为127.0.0.1，新的wsBaseUrl:', wsBaseUrl);
        }
      }
    } catch (e) {
      console.error('获取小程序环境信息失败:', e);
    }
    
    // 获取系统信息
    try {
      const systemInfo = wx.getSystemInfoSync();
      console.log('系统平台:', systemInfo.platform);
      
      // 针对开发者工具特殊处理
      if (systemInfo.platform === 'devtools') {
        if (wsBaseUrl.includes('localhost')) {
          wsBaseUrl = wsBaseUrl.replace('localhost', '127.0.0.1');
          console.log('开发工具环境中，将localhost替换为127.0.0.1，新的wsBaseUrl:', wsBaseUrl);
        }
      }
    } catch (e) {
      console.error('获取系统信息失败:', e);
    }
    
    // 从app.js中获取API上下文路径
    let contextPath = '';
    if (app.globalData.baseUrl && app.globalData.baseUrl.includes('/api')) {
      // 提取上下文路径，例如从http://127.0.0.1:8080/api中提取/api
      const match = app.globalData.baseUrl.match(/^https?:\/\/[^\/]+(\/[^\/]+)/);
      if (match && match[1]) {
        contextPath = match[1];
        console.log('从baseUrl中提取上下文路径:', contextPath);
      }
    }
    
    // 构建WebSocket URL，正确包含上下文路径
    const wsUrl = wsBaseUrl + contextPath + '/chat/ws';
    console.log('最终WebSocket URL:', wsUrl);
    return wsUrl;
  } catch (e) {
    console.error('获取WebSocket URL时出错:', e);
    // 返回默认URL，包含上下文路径
    return 'ws://127.0.0.1:8080/api/chat/ws';
  }
}

/**
 * 检查WebSocket URL是否有效
 * @param {string} url WebSocket URL
 * @returns {boolean} 是否有效
 */
function checkWsUrl(url) {
  console.log('检查WebSocket URL是否有效:', url);
  if (!url) {
    console.error('WebSocket URL为空');
    return false;
  }
  
  // 检查URL格式是否正确
  if (!url.startsWith('ws://') && !url.startsWith('wss://')) {
    console.error('WebSocket URL必须以ws://或wss://开头');
    return false;
  }
  
  // 检查是否包含IP或域名
  const urlPattern = /^(ws|wss):\/\/([^\/]+)(\/.*)?$/;
  const match = url.match(urlPattern);
  if (!match) {
    console.error('WebSocket URL格式不正确');
    return false;
  }
  
  const host = match[2];
  if (!host) {
    console.error('WebSocket URL缺少主机名');
    return false;
  }
  
  // 根据环境检查其他限制
  try {
    const accountInfo = wx.getAccountInfoSync();
    const envVersion = accountInfo.miniProgram.envVersion;
    
    if (envVersion !== 'develop') {
      // 非开发环境下，检查是否使用安全连接(wss)
      if (!url.startsWith('wss://') && !host.includes('127.0.0.1') && !host.includes('localhost')) {
        console.warn('非开发环境应使用wss://协议，但当前URL使用了ws://');
        // 仅作为警告，不要立即返回false
      }
    }
  } catch (e) {
    console.error('检查环境时出错:', e);
  }
  
  console.log('WebSocket URL校验通过');
  return true;
}

/**
 * 获取所有会话列表（合并用户和医护人员会话）
 * 从前端方便调用的统一接口
 */
const allConversations = () => {
  console.log('调用allConversations服务，获取所有会话列表');
  
  // 获取当前登录用户类型
  const app = getApp();
  const isStaff = app.globalData.isStaff;
  
  // 根据用户类型调用对应的接口
  if (isStaff) {
    console.log('当前为医护人员，获取医护人员会话列表');
    return getStaffConversations();
  } else {
    console.log('当前为普通用户，获取用户会话列表');
    return getUserConversations();
  }
};

/**
 * 获取医护人员咨询统计
 */
const getStaffConsultationStatistics = (staffId) => {
  console.log('调用getStaffConsultationStatistics服务，staffId:', staffId);
  
  if (!staffId) {
    console.error('staffId参数为空');
    return Promise.reject(new Error('医生ID不能为空'));
  }
  
  return request.get('/consult/statistics/staff', { staffId })
    .then(res => {
      console.log('获取医护人员咨询统计成功:', res);
      return res;
    })
    .catch(err => {
      console.error('获取医护人员咨询统计失败:', err);
      // 返回默认值，避免页面崩溃
      return {
        totalCount: 0,
        activeCount: 0
      };
    });
};

/**
 * 获取医护人员最近的咨询会话
 */
const getStaffRecentConversations = (staffId, limit = 5) => {
  console.log('调用getStaffRecentConversations服务，staffId:', staffId);
  
  if (!staffId) {
    console.error('staffId参数为空');
    return Promise.reject(new Error('医生ID不能为空'));
  }
  
  return request.get('/consult/conversation/staff/recent', { staffId, limit })
    .then(res => {
      console.log('获取医护人员最近咨询成功:', res);
      
      // 处理返回的会话数据
      if (Array.isArray(res)) {
        res = res.map(item => {
          // 添加用户信息处理
          console.log(`会话ID:${item.id} 用户ID:${item.userId} 用户名:${item.userName || '未知'}`);
          
          // 用户头像处理
          if (item.userAvatar) {
            console.log(`会话${item.id}的用户头像URL:`, item.userAvatar);
          } else if (item.avatar) {
            console.log(`会话${item.id}使用avatar字段作为用户头像:`, item.avatar);
            item.userAvatar = item.avatar;
          } else {
            console.log(`会话${item.id}没有头像，将使用默认头像`);
            item.userAvatar = '/static/images/default-avatar.png';
          }
          
          return item;
        });
      } else {
        console.warn('返回的不是数组类型:', typeof res);
      }
      
      return res;
    })
    .catch(err => {
      console.error('获取医护人员最近咨询失败:', err);
      return Promise.reject(err);
    });
};

/**
 * 创建医护人员与用户的会话
 */
const createStaffConversation = (userId) => {
  console.log('调用createStaffConversation服务，userId:', userId);
  
  if (!userId) {
    console.error('userId参数为空');
    return Promise.reject(new Error('用户ID不能为空'));
  }
  
  return request.post('/consult/conversation/staff', { userId: String(userId) })
    .then(res => {
      console.log('创建医护人员与用户会话成功:', res);
      return res;
    })
    .catch(err => {
      console.error('创建医护人员与用户会话失败:', err);
      return Promise.reject(err);
    });
};

/**
 * 医生端获取或创建与用户的会话
 */
const getOrCreateUserConversation = (userId) => {
  console.log('医生端获取或创建与用户的会话，userId:', userId);
  
  if (!userId) {
    console.error('用户ID参数为空');
    return Promise.reject(new Error('用户ID不能为空'));
  }
  
  // 尝试获取现有会话
  return request.get('/consult/conversation/get', { userId: String(userId) })
    .then(res => {
      if (res && res.id) {
        console.log('已存在会话:', res);
        return res;
      } else {
        // 没有现有会话，创建新会话
        console.log('没有现有会话，创建新会话');
        return createStaffConversation(userId);
      }
    })
    .catch(err => {
      console.error('获取会话失败, 尝试创建新会话:', err);
      return createStaffConversation(userId);
    });
};

module.exports = {
  getOrCreateConversation,
  createConversation,
  endConversation,
  getUserConversations,
  getStaffConversations,
  allConversations,
  getMessages,
  getMessageList,
  sendMessage,
  readMessages,
  getWsUrl,
  checkWsUrl,
  getStaffConsultationStatistics,
  getStaffRecentConversations,
  createStaffConversation,
  getOrCreateUserConversation
}; 